// $ANTLR 3.4 C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g 2012-10-25 16:38:25
package PL.practica6;

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class AnalizadorCParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ABRIRCORCHETE", "ABRIRLLAVE", "ABRIRPARENTESIS", "AND", "ANGULOS", "ASTERISCO", "BLANCO", "BREAK", "CADENA", "CARACTER", "CERRARCORCHETE", "CERRARLLAVE", "CERRARPARENTESIS", "COMA", "COMENTARIO", "DECREMENTO", "DIGITO", "DISTINTO", "DOSPUNTOS", "EXCLAMACION", "IDENT", "IF", "IGUAL", "INCREMENTO", "INTERROGANTE", "LETRA", "NUEVA_LINEA", "NUMERO", "OPERADORLOGICOS", "OPERADORUNITARIOS", "OR", "PRINTF", "RESTA", "RETORNAR", "SEPARADOR", "SUMA", "TIPO", "VOID", "WHILE", "CORCHETES"
    };

    public static final int EOF=-1;
    public static final int ABRIRCORCHETE=4;
    public static final int ABRIRLLAVE=5;
    public static final int ABRIRPARENTESIS=6;
    public static final int AND=7;
    public static final int ANGULOS=8;
    public static final int ASTERISCO=9;
    public static final int BLANCO=10;
    public static final int BREAK=11;
    public static final int CADENA=12;
    public static final int CARACTER=13;
    public static final int CERRARCORCHETE=14;
    public static final int CERRARLLAVE=15;
    public static final int CERRARPARENTESIS=16;
    public static final int COMA=17;
    public static final int COMENTARIO=18;
    public static final int DECREMENTO=19;
    public static final int DIGITO=20;
    public static final int DISTINTO=21;
    public static final int DOSPUNTOS=22;
    public static final int EXCLAMACION=23;
    public static final int IDENT=24;
    public static final int IF=25;
    public static final int IGUAL=26;
    public static final int INCREMENTO=27;
    public static final int INTERROGANTE=28;
    public static final int LETRA=29;
    public static final int NUEVA_LINEA=30;
    public static final int NUMERO=31;
    public static final int OPERADORLOGICOS=32;
    public static final int OPERADORUNITARIOS=33;
    public static final int OR=34;
    public static final int PRINTF=35;
    public static final int RESTA=36;
    public static final int RETORNAR=37;
    public static final int SEPARADOR=38;
    public static final int SUMA=39;
    public static final int TIPO=40;
    public static final int VOID=41;
    public static final int WHILE=42;
    public static final int CORCHETES=43;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public AnalizadorCParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public AnalizadorCParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
    }

    public String[] getTokenNames() { return AnalizadorCParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g"; }



    ArrayList <RecognitionException> errores = new ArrayList<RecognitionException>();

    public boolean listaVacia (){
        if (errores.isEmpty()){
          return true;
        }else
          return false;
    }

    public ArrayList getListaErrores(){return errores;}


    @Override
    public void reportError (RecognitionException e){
      System.out.println (getErrorMessage(e, getTokenNames()));
      errores.add(e);
    }




    // $ANTLR start "entrada"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:36:1: entrada : metodo ;
    public final void entrada() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:36:9: ( metodo )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:36:11: metodo
            {
            pushFollow(FOLLOW_metodo_in_entrada50);
            metodo();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "entrada"



    // $ANTLR start "ifWhile"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:39:1: ifWhile : ( IF | WHILE ) ABRIRPARENTESIS condiciones CERRARPARENTESIS ( bloque | bloqueLlaves ) ;
    public final void ifWhile() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:39:9: ( ( IF | WHILE ) ABRIRPARENTESIS condiciones CERRARPARENTESIS ( bloque | bloqueLlaves ) )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:39:11: ( IF | WHILE ) ABRIRPARENTESIS condiciones CERRARPARENTESIS ( bloque | bloqueLlaves )
            {
            if ( input.LA(1)==IF||input.LA(1)==WHILE ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            match(input,ABRIRPARENTESIS,FOLLOW_ABRIRPARENTESIS_in_ifWhile68); 

            pushFollow(FOLLOW_condiciones_in_ifWhile70);
            condiciones();

            state._fsp--;


            match(input,CERRARPARENTESIS,FOLLOW_CERRARPARENTESIS_in_ifWhile72); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:39:69: ( bloque | bloqueLlaves )
            int alt1=2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0==ASTERISCO||(LA1_0 >= BREAK && LA1_0 <= CARACTER)||(LA1_0 >= EXCLAMACION && LA1_0 <= IF)||LA1_0==NUMERO||LA1_0==PRINTF||LA1_0==TIPO||LA1_0==WHILE) ) {
                alt1=1;
            }
            else if ( (LA1_0==ABRIRLLAVE) ) {
                alt1=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;

            }
            switch (alt1) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:39:70: bloque
                    {
                    pushFollow(FOLLOW_bloque_in_ifWhile75);
                    bloque();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:39:78: bloqueLlaves
                    {
                    pushFollow(FOLLOW_bloqueLlaves_in_ifWhile78);
                    bloqueLlaves();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "ifWhile"



    // $ANTLR start "condicion"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:3: condicion : ( ( EXCLAMACION IDENT ) | ( operacion ( ( ANGULOS ( IGUAL )? ) | DISTINTO | IGUAL ) operacion ) );
    public final void condicion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:13: ( ( EXCLAMACION IDENT ) | ( operacion ( ( ANGULOS ( IGUAL )? ) | DISTINTO | IGUAL ) operacion ) )
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==EXCLAMACION) ) {
                alt4=1;
            }
            else if ( (LA4_0==ASTERISCO||(LA4_0 >= CADENA && LA4_0 <= CARACTER)||LA4_0==IDENT||LA4_0==NUMERO) ) {
                alt4=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;

            }
            switch (alt4) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:16: ( EXCLAMACION IDENT )
                    {
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:16: ( EXCLAMACION IDENT )
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:17: EXCLAMACION IDENT
                    {
                    match(input,EXCLAMACION,FOLLOW_EXCLAMACION_in_condicion90); 

                    match(input,IDENT,FOLLOW_IDENT_in_condicion92); 

                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:38: ( operacion ( ( ANGULOS ( IGUAL )? ) | DISTINTO | IGUAL ) operacion )
                    {
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:38: ( operacion ( ( ANGULOS ( IGUAL )? ) | DISTINTO | IGUAL ) operacion )
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:39: operacion ( ( ANGULOS ( IGUAL )? ) | DISTINTO | IGUAL ) operacion
                    {
                    pushFollow(FOLLOW_operacion_in_condicion98);
                    operacion();

                    state._fsp--;


                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:49: ( ( ANGULOS ( IGUAL )? ) | DISTINTO | IGUAL )
                    int alt3=3;
                    switch ( input.LA(1) ) {
                    case ANGULOS:
                        {
                        alt3=1;
                        }
                        break;
                    case DISTINTO:
                        {
                        alt3=2;
                        }
                        break;
                    case IGUAL:
                        {
                        alt3=3;
                        }
                        break;
                    default:
                        NoViableAltException nvae =
                            new NoViableAltException("", 3, 0, input);

                        throw nvae;

                    }

                    switch (alt3) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:50: ( ANGULOS ( IGUAL )? )
                            {
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:50: ( ANGULOS ( IGUAL )? )
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:51: ANGULOS ( IGUAL )?
                            {
                            match(input,ANGULOS,FOLLOW_ANGULOS_in_condicion102); 

                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:59: ( IGUAL )?
                            int alt2=2;
                            int LA2_0 = input.LA(1);

                            if ( (LA2_0==IGUAL) ) {
                                alt2=1;
                            }
                            switch (alt2) {
                                case 1 :
                                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:59: IGUAL
                                    {
                                    match(input,IGUAL,FOLLOW_IGUAL_in_condicion104); 

                                    }
                                    break;

                            }


                            }


                            }
                            break;
                        case 2 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:68: DISTINTO
                            {
                            match(input,DISTINTO,FOLLOW_DISTINTO_in_condicion109); 

                            }
                            break;
                        case 3 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:40:79: IGUAL
                            {
                            match(input,IGUAL,FOLLOW_IGUAL_in_condicion113); 

                            }
                            break;

                    }


                    pushFollow(FOLLOW_operacion_in_condicion116);
                    operacion();

                    state._fsp--;


                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "condicion"



    // $ANTLR start "condiciones"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:41:3: condiciones : condicion ( OPERADORLOGICOS condicion )* ;
    public final void condiciones() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:41:15: ( condicion ( OPERADORLOGICOS condicion )* )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:41:18: condicion ( OPERADORLOGICOS condicion )*
            {
            pushFollow(FOLLOW_condicion_in_condiciones127);
            condicion();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:41:28: ( OPERADORLOGICOS condicion )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( (LA5_0==OPERADORLOGICOS) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:41:29: OPERADORLOGICOS condicion
            	    {
            	    match(input,OPERADORLOGICOS,FOLLOW_OPERADORLOGICOS_in_condiciones130); 

            	    pushFollow(FOLLOW_condicion_in_condiciones132);
            	    condicion();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "condiciones"



    // $ANTLR start "operacion"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:42:3: operacion : parametros ( ( OPERADORUNITARIOS | ASTERISCO ) ( IDENT | NUMERO ) )* ;
    public final void operacion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:42:13: ( parametros ( ( OPERADORUNITARIOS | ASTERISCO ) ( IDENT | NUMERO ) )* )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:42:15: parametros ( ( OPERADORUNITARIOS | ASTERISCO ) ( IDENT | NUMERO ) )*
            {
            pushFollow(FOLLOW_parametros_in_operacion143);
            parametros();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:42:26: ( ( OPERADORUNITARIOS | ASTERISCO ) ( IDENT | NUMERO ) )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( (LA6_0==ASTERISCO||LA6_0==OPERADORUNITARIOS) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:42:27: ( OPERADORUNITARIOS | ASTERISCO ) ( IDENT | NUMERO )
            	    {
            	    if ( input.LA(1)==ASTERISCO||input.LA(1)==OPERADORUNITARIOS ) {
            	        input.consume();
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    if ( input.LA(1)==IDENT||input.LA(1)==NUMERO ) {
            	        input.consume();
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "operacion"



    // $ANTLR start "metodo"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:43:3: metodo : cabecerafuncion bloqueLlaves ;
    public final void metodo() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:43:10: ( cabecerafuncion bloqueLlaves )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:43:12: cabecerafuncion bloqueLlaves
            {
            pushFollow(FOLLOW_cabecerafuncion_in_metodo169);
            cabecerafuncion();

            state._fsp--;


            pushFollow(FOLLOW_bloqueLlaves_in_metodo172);
            bloqueLlaves();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "metodo"



    // $ANTLR start "bloque"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:3: bloque : ( ifWhile | condicionalaritmetico | ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR ) ) ;
    public final void bloque() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:10: ( ( ifWhile | condicionalaritmetico | ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR ) ) )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:12: ( ifWhile | condicionalaritmetico | ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR ) )
            {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:12: ( ifWhile | condicionalaritmetico | ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR ) )
            int alt8=3;
            alt8 = dfa8.predict(input);
            switch (alt8) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:13: ifWhile
                    {
                    pushFollow(FOLLOW_ifWhile_in_bloque182);
                    ifWhile();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:23: condicionalaritmetico
                    {
                    pushFollow(FOLLOW_condicionalaritmetico_in_bloque186);
                    condicionalaritmetico();

                    state._fsp--;


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:47: ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR )
                    {
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:47: ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR )
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:48: ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR
                    {
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:48: ( asignacion | printf | llamadafuncion | declaracion | BREAK )
                    int alt7=5;
                    switch ( input.LA(1) ) {
                    case IDENT:
                        {
                        int LA7_1 = input.LA(2);

                        if ( (LA7_1==IGUAL) ) {
                            alt7=1;
                        }
                        else if ( (LA7_1==ABRIRPARENTESIS) ) {
                            alt7=3;
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 7, 1, input);

                            throw nvae;

                        }
                        }
                        break;
                    case PRINTF:
                        {
                        alt7=2;
                        }
                        break;
                    case TIPO:
                        {
                        alt7=4;
                        }
                        break;
                    case BREAK:
                        {
                        alt7=5;
                        }
                        break;
                    default:
                        NoViableAltException nvae =
                            new NoViableAltException("", 7, 0, input);

                        throw nvae;

                    }

                    switch (alt7) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:49: asignacion
                            {
                            pushFollow(FOLLOW_asignacion_in_bloque192);
                            asignacion();

                            state._fsp--;


                            }
                            break;
                        case 2 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:60: printf
                            {
                            pushFollow(FOLLOW_printf_in_bloque194);
                            printf();

                            state._fsp--;


                            }
                            break;
                        case 3 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:67: llamadafuncion
                            {
                            pushFollow(FOLLOW_llamadafuncion_in_bloque196);
                            llamadafuncion();

                            state._fsp--;


                            }
                            break;
                        case 4 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:82: declaracion
                            {
                            pushFollow(FOLLOW_declaracion_in_bloque198);
                            declaracion();

                            state._fsp--;


                            }
                            break;
                        case 5 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:44:95: BREAK
                            {
                            match(input,BREAK,FOLLOW_BREAK_in_bloque201); 

                            }
                            break;

                    }


                    match(input,SEPARADOR,FOLLOW_SEPARADOR_in_bloque204); 

                    }


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "bloque"



    // $ANTLR start "bloqueLlaves"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:3: bloqueLlaves : ABRIRLLAVE ( ifWhile | condicionalaritmetico | ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR ) )* ( ret )? CERRARLLAVE ;
    public final void bloqueLlaves() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:16: ( ABRIRLLAVE ( ifWhile | condicionalaritmetico | ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR ) )* ( ret )? CERRARLLAVE )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:18: ABRIRLLAVE ( ifWhile | condicionalaritmetico | ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR ) )* ( ret )? CERRARLLAVE
            {
            match(input,ABRIRLLAVE,FOLLOW_ABRIRLLAVE_in_bloqueLlaves215); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:30: ( ifWhile | condicionalaritmetico | ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR ) )*
            loop10:
            do {
                int alt10=4;
                alt10 = dfa10.predict(input);
                switch (alt10) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:31: ifWhile
            	    {
            	    pushFollow(FOLLOW_ifWhile_in_bloqueLlaves219);
            	    ifWhile();

            	    state._fsp--;


            	    }
            	    break;
            	case 2 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:41: condicionalaritmetico
            	    {
            	    pushFollow(FOLLOW_condicionalaritmetico_in_bloqueLlaves223);
            	    condicionalaritmetico();

            	    state._fsp--;


            	    }
            	    break;
            	case 3 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:65: ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR )
            	    {
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:65: ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR )
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:66: ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR
            	    {
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:66: ( asignacion | printf | llamadafuncion | declaracion | BREAK )
            	    int alt9=5;
            	    switch ( input.LA(1) ) {
            	    case IDENT:
            	        {
            	        int LA9_1 = input.LA(2);

            	        if ( (LA9_1==IGUAL) ) {
            	            alt9=1;
            	        }
            	        else if ( (LA9_1==ABRIRPARENTESIS) ) {
            	            alt9=3;
            	        }
            	        else {
            	            NoViableAltException nvae =
            	                new NoViableAltException("", 9, 1, input);

            	            throw nvae;

            	        }
            	        }
            	        break;
            	    case PRINTF:
            	        {
            	        alt9=2;
            	        }
            	        break;
            	    case TIPO:
            	        {
            	        alt9=4;
            	        }
            	        break;
            	    case BREAK:
            	        {
            	        alt9=5;
            	        }
            	        break;
            	    default:
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 9, 0, input);

            	        throw nvae;

            	    }

            	    switch (alt9) {
            	        case 1 :
            	            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:67: asignacion
            	            {
            	            pushFollow(FOLLOW_asignacion_in_bloqueLlaves229);
            	            asignacion();

            	            state._fsp--;


            	            }
            	            break;
            	        case 2 :
            	            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:78: printf
            	            {
            	            pushFollow(FOLLOW_printf_in_bloqueLlaves231);
            	            printf();

            	            state._fsp--;


            	            }
            	            break;
            	        case 3 :
            	            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:85: llamadafuncion
            	            {
            	            pushFollow(FOLLOW_llamadafuncion_in_bloqueLlaves233);
            	            llamadafuncion();

            	            state._fsp--;


            	            }
            	            break;
            	        case 4 :
            	            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:100: declaracion
            	            {
            	            pushFollow(FOLLOW_declaracion_in_bloqueLlaves235);
            	            declaracion();

            	            state._fsp--;


            	            }
            	            break;
            	        case 5 :
            	            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:113: BREAK
            	            {
            	            match(input,BREAK,FOLLOW_BREAK_in_bloqueLlaves238); 

            	            }
            	            break;

            	    }


            	    match(input,SEPARADOR,FOLLOW_SEPARADOR_in_bloqueLlaves240); 

            	    }


            	    }
            	    break;

            	default :
            	    break loop10;
                }
            } while (true);


            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:132: ( ret )?
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0==RETORNAR) ) {
                alt11=1;
            }
            switch (alt11) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:45:132: ret
                    {
                    pushFollow(FOLLOW_ret_in_bloqueLlaves245);
                    ret();

                    state._fsp--;


                    }
                    break;

            }


            match(input,CERRARLLAVE,FOLLOW_CERRARLLAVE_in_bloqueLlaves248); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "bloqueLlaves"



    // $ANTLR start "vector"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:46:5: vector : ( ( ASTERISCO )? IDENT ( CORCHETES )* ) ;
    public final void vector() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:46:12: ( ( ( ASTERISCO )? IDENT ( CORCHETES )* ) )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:46:14: ( ( ASTERISCO )? IDENT ( CORCHETES )* )
            {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:46:14: ( ( ASTERISCO )? IDENT ( CORCHETES )* )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:46:15: ( ASTERISCO )? IDENT ( CORCHETES )*
            {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:46:15: ( ASTERISCO )?
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( (LA12_0==ASTERISCO) ) {
                alt12=1;
            }
            switch (alt12) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:46:15: ASTERISCO
                    {
                    match(input,ASTERISCO,FOLLOW_ASTERISCO_in_vector260); 

                    }
                    break;

            }


            match(input,IDENT,FOLLOW_IDENT_in_vector263); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:46:32: ( CORCHETES )*
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

                if ( (LA13_0==CORCHETES) ) {
                    alt13=1;
                }


                switch (alt13) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:46:32: CORCHETES
            	    {
            	    match(input,CORCHETES,FOLLOW_CORCHETES_in_vector265); 

            	    }
            	    break;

            	default :
            	    break loop13;
                }
            } while (true);


            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "vector"



    // $ANTLR start "parametros"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:47:5: parametros : ( vector | CADENA | NUMERO | CARACTER );
    public final void parametros() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:47:16: ( vector | CADENA | NUMERO | CARACTER )
            int alt14=4;
            switch ( input.LA(1) ) {
            case ASTERISCO:
            case IDENT:
                {
                alt14=1;
                }
                break;
            case CADENA:
                {
                alt14=2;
                }
                break;
            case NUMERO:
                {
                alt14=3;
                }
                break;
            case CARACTER:
                {
                alt14=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;

            }

            switch (alt14) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:47:18: vector
                    {
                    pushFollow(FOLLOW_vector_in_parametros278);
                    vector();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:47:27: CADENA
                    {
                    match(input,CADENA,FOLLOW_CADENA_in_parametros282); 

                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:47:35: NUMERO
                    {
                    match(input,NUMERO,FOLLOW_NUMERO_in_parametros285); 

                    }
                    break;
                case 4 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:47:43: CARACTER
                    {
                    match(input,CARACTER,FOLLOW_CARACTER_in_parametros288); 

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "parametros"



    // $ANTLR start "cabecerafuncion"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:48:5: cabecerafuncion : ( TIPO | VOID ) IDENT ABRIRPARENTESIS ( ( VOID | TIPO IDENT ) ( COMA TIPO parametros )* )? CERRARPARENTESIS ;
    public final void cabecerafuncion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:48:21: ( ( TIPO | VOID ) IDENT ABRIRPARENTESIS ( ( VOID | TIPO IDENT ) ( COMA TIPO parametros )* )? CERRARPARENTESIS )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:48:23: ( TIPO | VOID ) IDENT ABRIRPARENTESIS ( ( VOID | TIPO IDENT ) ( COMA TIPO parametros )* )? CERRARPARENTESIS
            {
            if ( (input.LA(1) >= TIPO && input.LA(1) <= VOID) ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            match(input,IDENT,FOLLOW_IDENT_in_cabecerafuncion309); 

            match(input,ABRIRPARENTESIS,FOLLOW_ABRIRPARENTESIS_in_cabecerafuncion311); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:48:59: ( ( VOID | TIPO IDENT ) ( COMA TIPO parametros )* )?
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( ((LA17_0 >= TIPO && LA17_0 <= VOID)) ) {
                alt17=1;
            }
            switch (alt17) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:48:60: ( VOID | TIPO IDENT ) ( COMA TIPO parametros )*
                    {
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:48:60: ( VOID | TIPO IDENT )
                    int alt15=2;
                    int LA15_0 = input.LA(1);

                    if ( (LA15_0==VOID) ) {
                        alt15=1;
                    }
                    else if ( (LA15_0==TIPO) ) {
                        alt15=2;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 15, 0, input);

                        throw nvae;

                    }
                    switch (alt15) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:48:61: VOID
                            {
                            match(input,VOID,FOLLOW_VOID_in_cabecerafuncion315); 

                            }
                            break;
                        case 2 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:48:67: TIPO IDENT
                            {
                            match(input,TIPO,FOLLOW_TIPO_in_cabecerafuncion318); 

                            match(input,IDENT,FOLLOW_IDENT_in_cabecerafuncion320); 

                            }
                            break;

                    }


                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:48:79: ( COMA TIPO parametros )*
                    loop16:
                    do {
                        int alt16=2;
                        int LA16_0 = input.LA(1);

                        if ( (LA16_0==COMA) ) {
                            alt16=1;
                        }


                        switch (alt16) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:48:80: COMA TIPO parametros
                    	    {
                    	    match(input,COMA,FOLLOW_COMA_in_cabecerafuncion324); 

                    	    match(input,TIPO,FOLLOW_TIPO_in_cabecerafuncion326); 

                    	    pushFollow(FOLLOW_parametros_in_cabecerafuncion328);
                    	    parametros();

                    	    state._fsp--;


                    	    }
                    	    break;

                    	default :
                    	    break loop16;
                        }
                    } while (true);


                    }
                    break;

            }


            match(input,CERRARPARENTESIS,FOLLOW_CERRARPARENTESIS_in_cabecerafuncion334); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "cabecerafuncion"



    // $ANTLR start "llamadafuncion"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:49:5: llamadafuncion : IDENT ABRIRPARENTESIS ( parametros ( COMA parametros )* )? CERRARPARENTESIS ;
    public final void llamadafuncion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:49:20: ( IDENT ABRIRPARENTESIS ( parametros ( COMA parametros )* )? CERRARPARENTESIS )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:49:22: IDENT ABRIRPARENTESIS ( parametros ( COMA parametros )* )? CERRARPARENTESIS
            {
            match(input,IDENT,FOLLOW_IDENT_in_llamadafuncion345); 

            match(input,ABRIRPARENTESIS,FOLLOW_ABRIRPARENTESIS_in_llamadafuncion347); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:49:44: ( parametros ( COMA parametros )* )?
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( (LA19_0==ASTERISCO||(LA19_0 >= CADENA && LA19_0 <= CARACTER)||LA19_0==IDENT||LA19_0==NUMERO) ) {
                alt19=1;
            }
            switch (alt19) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:49:46: parametros ( COMA parametros )*
                    {
                    pushFollow(FOLLOW_parametros_in_llamadafuncion351);
                    parametros();

                    state._fsp--;


                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:49:57: ( COMA parametros )*
                    loop18:
                    do {
                        int alt18=2;
                        int LA18_0 = input.LA(1);

                        if ( (LA18_0==COMA) ) {
                            alt18=1;
                        }


                        switch (alt18) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:49:58: COMA parametros
                    	    {
                    	    match(input,COMA,FOLLOW_COMA_in_llamadafuncion354); 

                    	    pushFollow(FOLLOW_parametros_in_llamadafuncion356);
                    	    parametros();

                    	    state._fsp--;


                    	    }
                    	    break;

                    	default :
                    	    break loop18;
                        }
                    } while (true);


                    }
                    break;

            }


            match(input,CERRARPARENTESIS,FOLLOW_CERRARPARENTESIS_in_llamadafuncion362); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "llamadafuncion"



    // $ANTLR start "printf"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:50:5: printf : PRINTF ABRIRPARENTESIS CADENA ( COMA IDENT )* CERRARPARENTESIS ;
    public final void printf() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:50:12: ( PRINTF ABRIRPARENTESIS CADENA ( COMA IDENT )* CERRARPARENTESIS )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:50:15: PRINTF ABRIRPARENTESIS CADENA ( COMA IDENT )* CERRARPARENTESIS
            {
            match(input,PRINTF,FOLLOW_PRINTF_in_printf374); 

            match(input,ABRIRPARENTESIS,FOLLOW_ABRIRPARENTESIS_in_printf376); 

            match(input,CADENA,FOLLOW_CADENA_in_printf378); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:50:45: ( COMA IDENT )*
            loop20:
            do {
                int alt20=2;
                int LA20_0 = input.LA(1);

                if ( (LA20_0==COMA) ) {
                    alt20=1;
                }


                switch (alt20) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:50:46: COMA IDENT
            	    {
            	    match(input,COMA,FOLLOW_COMA_in_printf381); 

            	    match(input,IDENT,FOLLOW_IDENT_in_printf383); 

            	    }
            	    break;

            	default :
            	    break loop20;
                }
            } while (true);


            match(input,CERRARPARENTESIS,FOLLOW_CERRARPARENTESIS_in_printf387); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "printf"



    // $ANTLR start "asignacion"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:51:5: asignacion : IDENT IGUAL ( operacion | llamadafuncion ) ;
    public final void asignacion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:51:16: ( IDENT IGUAL ( operacion | llamadafuncion ) )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:51:18: IDENT IGUAL ( operacion | llamadafuncion )
            {
            match(input,IDENT,FOLLOW_IDENT_in_asignacion399); 

            match(input,IGUAL,FOLLOW_IGUAL_in_asignacion401); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:51:30: ( operacion | llamadafuncion )
            int alt21=2;
            int LA21_0 = input.LA(1);

            if ( (LA21_0==ASTERISCO||(LA21_0 >= CADENA && LA21_0 <= CARACTER)||LA21_0==NUMERO) ) {
                alt21=1;
            }
            else if ( (LA21_0==IDENT) ) {
                int LA21_2 = input.LA(2);

                if ( (LA21_2==ABRIRPARENTESIS) ) {
                    alt21=2;
                }
                else if ( (LA21_2==ASTERISCO||LA21_2==OPERADORUNITARIOS||LA21_2==SEPARADOR||LA21_2==CORCHETES) ) {
                    alt21=1;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 21, 2, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 21, 0, input);

                throw nvae;

            }
            switch (alt21) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:51:31: operacion
                    {
                    pushFollow(FOLLOW_operacion_in_asignacion404);
                    operacion();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:51:43: llamadafuncion
                    {
                    pushFollow(FOLLOW_llamadafuncion_in_asignacion408);
                    llamadafuncion();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "asignacion"



    // $ANTLR start "declaracion"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:52:5: declaracion : TIPO IDENT ( COMA IDENT )* ;
    public final void declaracion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:52:17: ( TIPO IDENT ( COMA IDENT )* )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:52:19: TIPO IDENT ( COMA IDENT )*
            {
            match(input,TIPO,FOLLOW_TIPO_in_declaracion420); 

            match(input,IDENT,FOLLOW_IDENT_in_declaracion422); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:52:30: ( COMA IDENT )*
            loop22:
            do {
                int alt22=2;
                int LA22_0 = input.LA(1);

                if ( (LA22_0==COMA) ) {
                    alt22=1;
                }


                switch (alt22) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:52:31: COMA IDENT
            	    {
            	    match(input,COMA,FOLLOW_COMA_in_declaracion425); 

            	    match(input,IDENT,FOLLOW_IDENT_in_declaracion427); 

            	    }
            	    break;

            	default :
            	    break loop22;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "declaracion"



    // $ANTLR start "ret"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:53:5: ret : RETORNAR ( NUMERO | IDENT | CADENA )? SEPARADOR ;
    public final void ret() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:53:9: ( RETORNAR ( NUMERO | IDENT | CADENA )? SEPARADOR )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:53:11: RETORNAR ( NUMERO | IDENT | CADENA )? SEPARADOR
            {
            match(input,RETORNAR,FOLLOW_RETORNAR_in_ret440); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:53:20: ( NUMERO | IDENT | CADENA )?
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( (LA23_0==CADENA||LA23_0==IDENT||LA23_0==NUMERO) ) {
                alt23=1;
            }
            switch (alt23) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:
                    {
                    if ( input.LA(1)==CADENA||input.LA(1)==IDENT||input.LA(1)==NUMERO ) {
                        input.consume();
                        state.errorRecovery=false;
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        throw mse;
                    }


                    }
                    break;

            }


            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_ret451); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "ret"



    // $ANTLR start "condicionalaritmetico"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:54:5: condicionalaritmetico : condicion INTERROGANTE NUMERO DOSPUNTOS NUMERO SEPARADOR ;
    public final void condicionalaritmetico() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:54:26: ( condicion INTERROGANTE NUMERO DOSPUNTOS NUMERO SEPARADOR )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorCParser.g:54:28: condicion INTERROGANTE NUMERO DOSPUNTOS NUMERO SEPARADOR
            {
            pushFollow(FOLLOW_condicion_in_condicionalaritmetico461);
            condicion();

            state._fsp--;


            match(input,INTERROGANTE,FOLLOW_INTERROGANTE_in_condicionalaritmetico463); 

            match(input,NUMERO,FOLLOW_NUMERO_in_condicionalaritmetico465); 

            match(input,DOSPUNTOS,FOLLOW_DOSPUNTOS_in_condicionalaritmetico467); 

            match(input,NUMERO,FOLLOW_NUMERO_in_condicionalaritmetico469); 

            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_condicionalaritmetico471); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "condicionalaritmetico"

    // Delegated rules


    protected DFA8 dfa8 = new DFA8(this);
    protected DFA10 dfa10 = new DFA10(this);
    static final String DFA8_eotS =
        "\17\uffff";
    static final String DFA8_eofS =
        "\17\uffff";
    static final String DFA8_minS =
        "\1\11\2\uffff\1\6\1\uffff\1\11\1\30\1\6\5\11\1\30\1\11";
    static final String DFA8_maxS =
        "\1\52\2\uffff\1\53\1\uffff\1\37\1\30\1\53\3\46\2\53\1\37\1\46";
    static final String DFA8_acceptS =
        "\1\uffff\1\1\1\2\1\uffff\1\3\12\uffff";
    static final String DFA8_specialS =
        "\17\uffff}>";
    static final String[] DFA8_transitionS = {
            "\1\2\1\uffff\1\4\2\2\11\uffff\1\2\1\3\1\1\5\uffff\1\2\3\uffff"+
            "\1\4\4\uffff\1\4\1\uffff\1\1",
            "",
            "",
            "\1\4\1\uffff\2\2\13\uffff\1\2\4\uffff\1\5\6\uffff\1\2\11\uffff"+
            "\1\2",
            "",
            "\1\6\2\uffff\1\10\1\12\12\uffff\1\7\6\uffff\1\11",
            "\1\13",
            "\1\4\2\uffff\1\15\22\uffff\1\2\4\uffff\1\15\4\uffff\1\4\4\uffff"+
            "\1\14",
            "\1\15\22\uffff\1\2\4\uffff\1\15\4\uffff\1\4",
            "\1\15\22\uffff\1\2\4\uffff\1\15\4\uffff\1\4",
            "\1\15\22\uffff\1\2\4\uffff\1\15\4\uffff\1\4",
            "\1\15\22\uffff\1\2\4\uffff\1\15\4\uffff\1\4\4\uffff\1\14",
            "\1\15\22\uffff\1\2\4\uffff\1\15\4\uffff\1\4\4\uffff\1\14",
            "\1\16\6\uffff\1\16",
            "\1\15\22\uffff\1\2\4\uffff\1\15\4\uffff\1\4"
    };

    static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
    static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
    static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS);
    static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS);
    static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
    static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
    static final short[][] DFA8_transition;

    static {
        int numStates = DFA8_transitionS.length;
        DFA8_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]);
        }
    }

    class DFA8 extends DFA {

        public DFA8(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 8;
            this.eot = DFA8_eot;
            this.eof = DFA8_eof;
            this.min = DFA8_min;
            this.max = DFA8_max;
            this.accept = DFA8_accept;
            this.special = DFA8_special;
            this.transition = DFA8_transition;
        }
        public String getDescription() {
            return "44:12: ( ifWhile | condicionalaritmetico | ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR ) )";
        }
    }
    static final String DFA10_eotS =
        "\20\uffff";
    static final String DFA10_eofS =
        "\20\uffff";
    static final String DFA10_minS =
        "\1\11\3\uffff\1\6\1\uffff\1\11\1\30\1\6\5\11\1\30\1\11";
    static final String DFA10_maxS =
        "\1\52\3\uffff\1\53\1\uffff\1\37\1\30\1\53\3\46\2\53\1\37\1\46";
    static final String DFA10_acceptS =
        "\1\uffff\1\4\1\1\1\2\1\uffff\1\3\12\uffff";
    static final String DFA10_specialS =
        "\20\uffff}>";
    static final String[] DFA10_transitionS = {
            "\1\3\1\uffff\1\5\2\3\1\uffff\1\1\7\uffff\1\3\1\4\1\2\5\uffff"+
            "\1\3\3\uffff\1\5\1\uffff\1\1\2\uffff\1\5\1\uffff\1\2",
            "",
            "",
            "",
            "\1\5\1\uffff\2\3\13\uffff\1\3\4\uffff\1\6\6\uffff\1\3\11\uffff"+
            "\1\3",
            "",
            "\1\7\2\uffff\1\11\1\13\12\uffff\1\10\6\uffff\1\12",
            "\1\14",
            "\1\5\2\uffff\1\16\22\uffff\1\3\4\uffff\1\16\4\uffff\1\5\4\uffff"+
            "\1\15",
            "\1\16\22\uffff\1\3\4\uffff\1\16\4\uffff\1\5",
            "\1\16\22\uffff\1\3\4\uffff\1\16\4\uffff\1\5",
            "\1\16\22\uffff\1\3\4\uffff\1\16\4\uffff\1\5",
            "\1\16\22\uffff\1\3\4\uffff\1\16\4\uffff\1\5\4\uffff\1\15",
            "\1\16\22\uffff\1\3\4\uffff\1\16\4\uffff\1\5\4\uffff\1\15",
            "\1\17\6\uffff\1\17",
            "\1\16\22\uffff\1\3\4\uffff\1\16\4\uffff\1\5"
    };

    static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
    static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
    static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
    static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
    static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
    static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
    static final short[][] DFA10_transition;

    static {
        int numStates = DFA10_transitionS.length;
        DFA10_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
        }
    }

    class DFA10 extends DFA {

        public DFA10(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = DFA10_eot;
            this.eof = DFA10_eof;
            this.min = DFA10_min;
            this.max = DFA10_max;
            this.accept = DFA10_accept;
            this.special = DFA10_special;
            this.transition = DFA10_transition;
        }
        public String getDescription() {
            return "()* loopback of 45:30: ( ifWhile | condicionalaritmetico | ( ( asignacion | printf | llamadafuncion | declaracion | BREAK ) SEPARADOR ) )*";
        }
    }
 

    public static final BitSet FOLLOW_metodo_in_entrada50 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_ifWhile60 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_ABRIRPARENTESIS_in_ifWhile68 = new BitSet(new long[]{0x0000000081803200L});
    public static final BitSet FOLLOW_condiciones_in_ifWhile70 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_CERRARPARENTESIS_in_ifWhile72 = new BitSet(new long[]{0x0000050883803A20L});
    public static final BitSet FOLLOW_bloque_in_ifWhile75 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_bloqueLlaves_in_ifWhile78 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_EXCLAMACION_in_condicion90 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_IDENT_in_condicion92 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_operacion_in_condicion98 = new BitSet(new long[]{0x0000000004200100L});
    public static final BitSet FOLLOW_ANGULOS_in_condicion102 = new BitSet(new long[]{0x0000000085003200L});
    public static final BitSet FOLLOW_IGUAL_in_condicion104 = new BitSet(new long[]{0x0000000081003200L});
    public static final BitSet FOLLOW_DISTINTO_in_condicion109 = new BitSet(new long[]{0x0000000081003200L});
    public static final BitSet FOLLOW_IGUAL_in_condicion113 = new BitSet(new long[]{0x0000000081003200L});
    public static final BitSet FOLLOW_operacion_in_condicion116 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_condicion_in_condiciones127 = new BitSet(new long[]{0x0000000100000002L});
    public static final BitSet FOLLOW_OPERADORLOGICOS_in_condiciones130 = new BitSet(new long[]{0x0000000081803200L});
    public static final BitSet FOLLOW_condicion_in_condiciones132 = new BitSet(new long[]{0x0000000100000002L});
    public static final BitSet FOLLOW_parametros_in_operacion143 = new BitSet(new long[]{0x0000000200000202L});
    public static final BitSet FOLLOW_set_in_operacion146 = new BitSet(new long[]{0x0000000081000000L});
    public static final BitSet FOLLOW_set_in_operacion153 = new BitSet(new long[]{0x0000000200000202L});
    public static final BitSet FOLLOW_cabecerafuncion_in_metodo169 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_bloqueLlaves_in_metodo172 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ifWhile_in_bloque182 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_condicionalaritmetico_in_bloque186 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_asignacion_in_bloque192 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_printf_in_bloque194 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_llamadafuncion_in_bloque196 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_declaracion_in_bloque198 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_BREAK_in_bloque201 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_bloque204 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ABRIRLLAVE_in_bloqueLlaves215 = new BitSet(new long[]{0x000005288380BA00L});
    public static final BitSet FOLLOW_ifWhile_in_bloqueLlaves219 = new BitSet(new long[]{0x000005288380BA00L});
    public static final BitSet FOLLOW_condicionalaritmetico_in_bloqueLlaves223 = new BitSet(new long[]{0x000005288380BA00L});
    public static final BitSet FOLLOW_asignacion_in_bloqueLlaves229 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_printf_in_bloqueLlaves231 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_llamadafuncion_in_bloqueLlaves233 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_declaracion_in_bloqueLlaves235 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_BREAK_in_bloqueLlaves238 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_bloqueLlaves240 = new BitSet(new long[]{0x000005288380BA00L});
    public static final BitSet FOLLOW_ret_in_bloqueLlaves245 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_CERRARLLAVE_in_bloqueLlaves248 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASTERISCO_in_vector260 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_IDENT_in_vector263 = new BitSet(new long[]{0x0000080000000002L});
    public static final BitSet FOLLOW_CORCHETES_in_vector265 = new BitSet(new long[]{0x0000080000000002L});
    public static final BitSet FOLLOW_vector_in_parametros278 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CADENA_in_parametros282 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NUMERO_in_parametros285 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CARACTER_in_parametros288 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_cabecerafuncion301 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_IDENT_in_cabecerafuncion309 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_ABRIRPARENTESIS_in_cabecerafuncion311 = new BitSet(new long[]{0x0000030000010000L});
    public static final BitSet FOLLOW_VOID_in_cabecerafuncion315 = new BitSet(new long[]{0x0000000000030000L});
    public static final BitSet FOLLOW_TIPO_in_cabecerafuncion318 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_IDENT_in_cabecerafuncion320 = new BitSet(new long[]{0x0000000000030000L});
    public static final BitSet FOLLOW_COMA_in_cabecerafuncion324 = new BitSet(new long[]{0x0000010000000000L});
    public static final BitSet FOLLOW_TIPO_in_cabecerafuncion326 = new BitSet(new long[]{0x0000000081003200L});
    public static final BitSet FOLLOW_parametros_in_cabecerafuncion328 = new BitSet(new long[]{0x0000000000030000L});
    public static final BitSet FOLLOW_CERRARPARENTESIS_in_cabecerafuncion334 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_llamadafuncion345 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_ABRIRPARENTESIS_in_llamadafuncion347 = new BitSet(new long[]{0x0000000081013200L});
    public static final BitSet FOLLOW_parametros_in_llamadafuncion351 = new BitSet(new long[]{0x0000000000030000L});
    public static final BitSet FOLLOW_COMA_in_llamadafuncion354 = new BitSet(new long[]{0x0000000081003200L});
    public static final BitSet FOLLOW_parametros_in_llamadafuncion356 = new BitSet(new long[]{0x0000000000030000L});
    public static final BitSet FOLLOW_CERRARPARENTESIS_in_llamadafuncion362 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PRINTF_in_printf374 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_ABRIRPARENTESIS_in_printf376 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_CADENA_in_printf378 = new BitSet(new long[]{0x0000000000030000L});
    public static final BitSet FOLLOW_COMA_in_printf381 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_IDENT_in_printf383 = new BitSet(new long[]{0x0000000000030000L});
    public static final BitSet FOLLOW_CERRARPARENTESIS_in_printf387 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_asignacion399 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_IGUAL_in_asignacion401 = new BitSet(new long[]{0x0000000081003200L});
    public static final BitSet FOLLOW_operacion_in_asignacion404 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_llamadafuncion_in_asignacion408 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TIPO_in_declaracion420 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_IDENT_in_declaracion422 = new BitSet(new long[]{0x0000000000020002L});
    public static final BitSet FOLLOW_COMA_in_declaracion425 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_IDENT_in_declaracion427 = new BitSet(new long[]{0x0000000000020002L});
    public static final BitSet FOLLOW_RETORNAR_in_ret440 = new BitSet(new long[]{0x0000004081001000L});
    public static final BitSet FOLLOW_SEPARADOR_in_ret451 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_condicion_in_condicionalaritmetico461 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_INTERROGANTE_in_condicionalaritmetico463 = new BitSet(new long[]{0x0000000080000000L});
    public static final BitSet FOLLOW_NUMERO_in_condicionalaritmetico465 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_DOSPUNTOS_in_condicionalaritmetico467 = new BitSet(new long[]{0x0000000080000000L});
    public static final BitSet FOLLOW_NUMERO_in_condicionalaritmetico469 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_condicionalaritmetico471 = new BitSet(new long[]{0x0000000000000002L});

}